<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Promise的API</title>
</head>

<body>

</body>
<script>
  /*
  1、Promise构造函数：promise(excutor){}
      excutor函数：同步执行，(resolve,reject)=>{}
      resolve函数：内部定义成功时我们调用的函数 value =>{}
      reject函数：内部定义失败时我们调用的函数 reason =>{}
      说明：excutor会在promise内部立即同步回调，异步操作在执行器中执行

  2、Promise.prototype.then方法：(onResolved,onRejected)=>{}
      onResolved函数：成功的回调函数 (value)=>{}
      onRejected函数：失败的回调函数 (reason)=>{}
      说明：指定用于得到成功value的成功回调和用于得到失败reason的失败回调，返回一个新的promise对象

  3、Promise.prototype.catch方法：(onRejected)=>{}
      onRejected函数：失败的回调函数  (reason)=>{}
      说明：then()的语法糖，相当于then(undefined,onRejected)

  4、Promise.resolve方法：(value)=>{}
      value：成功的数据或promise对象
      说明：返回一个成功/失败的promise对象

  5、Promise.reject方法：(reason)=>{}
      reason：失败的原因
      说明：返回一个失败的promise对象

  6、Promise.all方法：(promises)=>{}
      promises：包含n个promise的数组
      说明：返回一个新的promise，只有所有的promise都成功才成功，只要有一个失败了就直接失败

  7、Promise.race方法：(promises)=>{}
      promises：包含n个promise的数组
      说明：返回一个新的promise，第一个完成的promise的结果状态就是最终的结果状态

  8、Promise.any()
      接收一个Promise可迭代对象，只要其中的一个 promise 成功，就返回那个已经成功的 promise 。
      如果可迭代对象中没有一个 promise 成功（即所有的 promises 都失败/拒绝），就返回一个失败的 promise 和AggregateError类型的实例，
      它是 Error 的一个子类，用于把单一的错误集合在一起。本质上，这个方法和Promise.all()是相反的。

  9、Promise.allSettled()
      该Promise.allSettled()方法返回一个在所有给定的promise都已经fulfilled或rejected后的promise，并带有一个对象数组，每个对象表示对应的promise结果。
      当您有多个彼此不依赖的异步任务成功完成时，或者您总是想知道每个promise的结果时，通常使用它。
      相比之下，Promise.all() 更适合彼此相互依赖或者在其中任何一个reject时立即结束。


   */

  new Promise((resolve, reject) => {
    setTimeout(() => {
      // resolve('成功的数据');
      reject('失败的数据');
    }, 1000);
  }).then(value => {
    console.log('onResolved1', value);
  }).catch(reason => {
    console.log('onRejected()1', reason);
  })

  //  产生一个成功值为1的promise对象
  const p1 = new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(1);
    }, 100);
  })
  const p2 = Promise.resolve(2);
  const p3 = Promise.reject(3);
  p1.then(value => { console.log(value) })  //1
  p2.then(value => { console.log(value) })  //2
  p3.then(null, reason => { console.log(reason) })  //3
  p3.catch(reason => { console.log(reason) }) //3

  // const pAll = Promise.all([p1, p2, p3]);
  const pAll = Promise.all([p1, p2]);
  pAll.then(
    values => {
      console.log('all onResolved()', values);
    },
    reason => {
      console.log('all onRejected()', reason);
    }
  );  //all onResolved() (2) [1, 2]

  // 第一个完成的promise的结果状态就是最终的结果状态
  const pRace = Promise.race([p1, p2, p3]);
  pRace.then(
    values => {
      console.log('race onResolved()', values);
    },
    reason => {
      console.log('race onRejected()', reason);
    }
  )   //race onResolved() 2

  const pAny = Promise.race([p1, p2, p3]);
  pAny.then(
    values => {
      console.log('any onResolved()', values);
    },
    reason => {
      console.log('any onRejected()', reason);
    }
  )   //any onResolved() 2




</script>

</html>